{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 0. Import Libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "!pip install pandas\n",
    "!pip install matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import tensorflow.keras as keras\n",
    "from tensorflow.keras import backend as K\n",
    "from tensorflow.keras.layers import *\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from scipy.io import loadmat\n",
    "from scipy.io import savemat\n",
    "import math\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy.random import seed\n",
    "seed(0)\n",
    "tf.random.set_seed(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Define Something in Advance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Initialize the Grid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "delta = 0.05\n",
    "x_domain = np.arange(0, 1+delta, delta)\n",
    "y_domain = np.arange(0, 1+delta, delta)\n",
    "x_mesh,y_mesh = np.meshgrid(x_domain, y_domain)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Define Physical Info."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    suppose: \n",
    "    x = x[0];\n",
    "    y = x[1];\n",
    "    uxy = x[2]; \n",
    "    dudx = x[3];\n",
    "    dudy = x[4];\n",
    "    du2dx2 = x[5];\n",
    "    du2dy2 = x[6];\n",
    "    du2dxdy = x[7];\n",
    "    laplace = x[8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "k=5\n",
    "governing_equation_components = []\n",
    "governing_equation_components.append(Lambda(lambda x: x[5]))\n",
    "governing_equation_components.append(Lambda(lambda x: x[6]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "governing_equation_mask = x_mesh*0\n",
    "governing_equation_mask[1:-1,1:-1] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "fx = governing_equation_mask*(x_mesh*0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "estimate_equation_form = True\n",
    "#equation_component_combination = [1.0,2.0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Define the Observations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    suppose: \n",
    "    x = x[0];\n",
    "    y = x[1];\n",
    "    uxy = x[2]; \n",
    "    dudx = x[3];\n",
    "    dudy = x[4];\n",
    "    du2dx2 = x[5];\n",
    "    du2dy2 = x[6];\n",
    "    du2dxdy = x[7];\n",
    "    laplace = x[8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_components = []\n",
    "observation_components.append(Lambda(lambda x: x[2]))\n",
    "observation_components.append(Lambda(lambda x: x[3]))\n",
    "observation_components.append(Lambda(lambda x: x[4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    format: [x,y,combination,value]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "truth_smooth = loadmat('data.mat')['uxy_list'][-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Noise 5%"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "truth_data = loadmat('data.mat')['uxy_list'][-1] + np.random.normal(loc=0.0, scale=0.05, size=x_mesh.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(21, 21)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "truth_data.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "observation_data = []\n",
    "\n",
    "theta_list = np.linspace(0,np.pi*2,800)\n",
    "for theta in theta_list:\n",
    "    x = x_theta(theta)\n",
    "    y = y_theta(theta)\n",
    "    comb = [1,0,0]\n",
    "    v = U(x,y)\n",
    "    observation_data.append([x,y,comb,v])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data = []\n",
    "for x,y,v in zip(x_mesh.ravel(),y_mesh.ravel(),truth_data.ravel()):\n",
    "    comb = [1,0,0]\n",
    "    observation_data.append([x,y,comb,v])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Define PICN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_x_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[-1.0/delta]], [[1.0/delta]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_x2_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]], [[-2.0/delta**2]], [[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_y_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[-1.0/delta]]], [[[1.0/delta]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_y2_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]]], [[[-2.0/delta**2]]], [[[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_xy_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]], [[-1.0/delta**2]]], [[[-1.0/delta**2]], [[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def laplace_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[0]], [[1.0/delta**2]], [[0]]], [[[1.0/delta**2]], [[-4.0/delta**2]], [[1.0/delta**2]]], [[[0]], [[1.0/delta**2]], [[0]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputs = [keras.layers.Input(shape=(1,1,1)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1)),\n",
    "          keras.layers.Input(shape=(len(observation_data),len(observation_components)*4)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1))]\n",
    "\n",
    "hidden_field = keras.layers.Conv2DTranspose(filters=1, \n",
    "                                            kernel_size=[len(y_domain)+4,len(x_domain)+4], \n",
    "                                            activation='linear')(inputs[0])\n",
    "coordinates_x = inputs[1]\n",
    "coordinates_y = inputs[2]\n",
    "field = keras.layers.Conv2D(filters=1, \n",
    "                            kernel_size=3, \n",
    "                            padding='valid', \n",
    "                            activation=Lambda(lambda x: x))(hidden_field)\n",
    "gradient_x_field = keras.layers.Conv2D(filters=1, \n",
    "                                     kernel_size=[1,2], \n",
    "                                     padding='valid',\n",
    "                                     use_bias=False,\n",
    "                                     trainable=False,\n",
    "                                     kernel_initializer=gradient_x_kernal_init)(field)\n",
    "gradient_x2_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[1,3], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_x2_kernal_init)(field)\n",
    "gradient_y_field = keras.layers.Conv2D(filters=1, \n",
    "                                     kernel_size=[2,1], \n",
    "                                     padding='valid',\n",
    "                                     use_bias=False,\n",
    "                                     trainable=False,\n",
    "                                     kernel_initializer=gradient_y_kernal_init)(field)\n",
    "gradient_y2_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[3,1], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_y2_kernal_init)(field)\n",
    "gradient_xy_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[2,2], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_xy_kernal_init)(field)\n",
    "laplace_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[3,3], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=laplace_kernal_init)(field)\n",
    "phycial_fields = [coordinates_x,\n",
    "                  coordinates_y,\n",
    "                  field[:,1:-1,1:-1,:],\n",
    "                  gradient_x_field[:,1:-1,1:,:],\n",
    "                  gradient_y_field[:,1:,1:-1,:],\n",
    "                  gradient_x2_field[:,1:-1,:,:],\n",
    "                  gradient_y2_field[:,:,1:-1,:],\n",
    "                  gradient_xy_field[:,1:,1:,:],\n",
    "                  laplace_field]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "if estimate_equation_form==True:\n",
    "    tf_governing_equation_components = [component(phycial_fields) for component in governing_equation_components]\n",
    "    concat_equation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_governing_equation_components)\n",
    "    governing_equation = keras.layers.Conv2D(filters=1, \n",
    "                                             kernel_size=[1,1], \n",
    "                                             padding='valid',\n",
    "                                             use_bias=False)(concat_equation_components)*inputs[4]\n",
    "else:\n",
    "    tf_weighted_governing_equation_components = [weight*component(phycial_fields) for [weight,component] in zip(equation_component_combination,governing_equation_components)]\n",
    "    concat_weighted_equation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_weighted_governing_equation_components)\n",
    "    governing_equation = Lambda(lambda x: tf.reduce_sum(x,axis=-1,keepdims=True))(concat_weighted_equation_components)*inputs[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf_observation_components = [component(phycial_fields) for component in observation_components]\n",
    "concat_observation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_observation_components)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "left_x_position_index_list = []\n",
    "right_x_position_index_list = []\n",
    "left_x_position_weight_list = []\n",
    "right_x_position_weight_list = []\n",
    "\n",
    "bottom_y_position_index_list = []\n",
    "top_y_position_index_list = []\n",
    "bottom_y_position_weight_list = []\n",
    "top_y_position_weight_list = []\n",
    "\n",
    "\n",
    "for data in observation_data:\n",
    "    \n",
    "    left_x_position_index = int(np.floor((data[0] - x_domain[0])/delta))\n",
    "    right_x_position_index = left_x_position_index + 1\n",
    "    left_x_position_weight = 1-(data[0] - (x_domain[0]+delta*left_x_position_index))/delta\n",
    "    right_x_position_weight = 1-left_x_position_weight\n",
    "    \n",
    "    bottom_y_position_index = int(np.floor((data[1] - y_domain[0])/delta))\n",
    "    top_y_position_index = bottom_y_position_index + 1\n",
    "    bottom_y_position_weight = 1-(data[1] - (y_domain[0]+delta*bottom_y_position_index))/delta\n",
    "    top_y_position_weight = 1-bottom_y_position_weight\n",
    "    \n",
    "    if data[0] <= x_domain[0] + 1e-8:\n",
    "        left_x_position_index = 0\n",
    "        right_x_position_index = 1\n",
    "        left_x_position_weight = 1\n",
    "        right_x_position_weight = 0\n",
    "    if data[0] >= x_domain[-1] - 1e-8:\n",
    "        left_x_position_index = len(x_domain)-2\n",
    "        right_x_position_index = len(x_domain)-1\n",
    "        left_x_position_weight = 0\n",
    "        right_x_position_weight = 1\n",
    "    if data[1] <= y_domain[0] + 1e-8:\n",
    "        bottom_y_position_index = 0\n",
    "        top_y_position_index = 1\n",
    "        bottom_y_position_weight = 1\n",
    "        top_y_position_weight = 0\n",
    "    if data[1] >= y_domain[-1] - 1e-8:\n",
    "        bottom_y_position_index = len(y_domain)-2\n",
    "        top_y_position_index = len(y_domain)-1\n",
    "        bottom_y_position_weight = 0\n",
    "        top_y_position_weight = 1\n",
    "    \n",
    "    left_x_position_index_list.append(left_x_position_index)\n",
    "    right_x_position_index_list.append(right_x_position_index)\n",
    "    left_x_position_weight_list.append(left_x_position_weight)\n",
    "    right_x_position_weight_list.append(right_x_position_weight)\n",
    "\n",
    "    bottom_y_position_index_list.append(bottom_y_position_index)\n",
    "    top_y_position_index_list.append(top_y_position_index)\n",
    "    bottom_y_position_weight_list.append(bottom_y_position_weight)\n",
    "    top_y_position_weight_list.append(top_y_position_weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "left_bottom_indices = tf.constant([[0,y,x] for x,y in zip(left_x_position_index_list,bottom_y_position_index_list)])\n",
    "left_top_indices = tf.constant([[0,y,x] for x,y in zip(left_x_position_index_list,top_y_position_index_list)])\n",
    "right_bottom_indices = tf.constant([[0,y,x] for x,y in zip(right_x_position_index_list,bottom_y_position_index_list)])\n",
    "right_top_indices = tf.constant([[0,y,x] for x,y in zip(right_x_position_index_list,top_y_position_index_list)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_left_bottom_part = Lambda(lambda x: tf.gather_nd(x,left_bottom_indices))(concat_observation_components)\n",
    "observation_data_left_top_part = Lambda(lambda x: tf.gather_nd(x,left_top_indices))(concat_observation_components)\n",
    "observation_data_right_bottom_part = Lambda(lambda x: tf.gather_nd(x,right_bottom_indices))(concat_observation_components)\n",
    "observation_data_right_top_part = Lambda(lambda x: tf.gather_nd(x,right_top_indices))(concat_observation_components)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_four_part = Lambda(lambda x: tf.expand_dims(tf.concat(x,axis=-1),axis=0))([observation_data_left_bottom_part,observation_data_left_top_part,observation_data_right_bottom_part,observation_data_right_top_part])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_interpolation_weights = np.expand_dims(\n",
    "np.asarray([np.concatenate([(np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*left_x_position_weight_list[i]*bottom_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*left_x_position_weight_list[i]*top_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*right_x_position_weight_list[i]*bottom_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*right_x_position_weight_list[i]*top_y_position_weight_list[i]],axis=-1) for i in range(len(observation_data))]),\n",
    "    axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "observations = Lambda(lambda x: tf.reduce_sum(x[0]*x[1],axis=-1))([inputs[3][0,:,:],observation_data_four_part])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "pde_model = keras.Model(inputs=inputs[:3], outputs=phycial_fields)\n",
    "pde_model_train = keras.Model(inputs=inputs, outputs=[governing_equation,observations])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. Prepare the Training Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 1, 1, 1)\n"
     ]
    }
   ],
   "source": [
    "unit_constant = np.asarray([[[[1.0]]]],dtype=np.float32)\n",
    "training_input_data_0 = unit_constant\n",
    "print(training_input_data_0.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_1 = np.expand_dims(x_mesh.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_2 = np.expand_dims(y_mesh.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 441, 12)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_3 = observation_data_interpolation_weights.astype(np.float32)\n",
    "print(training_input_data_3.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_4 = np.expand_dims(governing_equation_mask.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_label_data_0 = np.expand_dims(fx.astype(np.float32),axis=[0,-1])\n",
    "print(training_label_data_0.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 441)\n"
     ]
    }
   ],
   "source": [
    "training_label_data_1 = np.expand_dims(np.asarray([data[3] for data in observation_data]),axis=[0])\n",
    "print(training_label_data_1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_input_data = [training_input_data_0,training_input_data_1,training_input_data_2,training_input_data_3,training_input_data_4]\n",
    "training_label_data = [training_label_data_0,training_label_data_1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7. Train the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['loss', 'tf_op_layer_Mul_loss', 'lambda_13_loss']\n"
     ]
    }
   ],
   "source": [
    "pde_model_train.compile(optimizer=keras.optimizers.Adam(), loss=\"mse\")\n",
    "pde_model_train.save_weights('picn_initial_weights.h5')\n",
    "temp_history = pde_model_train.fit(x=training_input_data, y=training_label_data, epochs=1, verbose=0)\n",
    "history_keys = []\n",
    "for key in temp_history.history.keys():\n",
    "    history_keys.append(key)\n",
    "print(history_keys)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def record_predictions():\n",
    "    [_, _, uxy, dudx, dudy, d2udx2, d2udy2, d2udxdy, laplace] = pde_model.predict(training_input_data[:3])\n",
    "    uxy_list.append(uxy[:,:,:,0])\n",
    "    dudx_list.append(dudx[:,:,:,0])\n",
    "    dudy_list.append(dudy[:,:,:,0])\n",
    "    d2udx2_list.append(d2udx2[:,:,:,0])\n",
    "    d2udy2_list.append(d2udy2[:,:,:,0])\n",
    "    d2udxdy_list.append(d2udxdy[:,:,:,0])\n",
    "    laplace_list.append(laplace[:,:,:,0])\n",
    "\n",
    "class Per_X_Epoch_Record(tf.keras.callbacks.Callback):\n",
    "    def __init__(self, record_interval, verbose=1):\n",
    "        super(tf.keras.callbacks.Callback, self).__init__()\n",
    "        self.total_loss = history_keys[0]\n",
    "        self.domain_loss = history_keys[1]\n",
    "        self.bdc_loss = history_keys[2]\n",
    "        self.previous_total_loss = 9999999\n",
    "        self.record_interval = record_interval;\n",
    "        self.verbose = verbose\n",
    "\n",
    "    def on_epoch_end(self, epoch, logs={}):\n",
    "        \n",
    "        if epoch%self.record_interval == 0:\n",
    "            \n",
    "            current_total_loss = logs.get(self.total_loss)\n",
    "            current_domain_loss = logs.get(self.domain_loss)\n",
    "            current_bdc_loss = logs.get(self.bdc_loss)\n",
    "            \n",
    "            epoch_number_list.append(epoch)\n",
    "            total_loss_list.append(current_total_loss)\n",
    "            domain_loss_list.append(current_domain_loss)\n",
    "            boundary_loss_list.append(current_bdc_loss)\n",
    "        \n",
    "            if current_total_loss < self.previous_total_loss:\n",
    "                self.previous_total_loss = current_total_loss\n",
    "                pde_model_train.save_weights('picn_best_weights.h5')\n",
    "            \n",
    "            if self.verbose > 0:\n",
    "                print(\"epoch: {:10.5f} | total_loss: {:10.5f} | domain_loss: {:10.5f} | bdc_loss: {:10.5f}\".format(epoch,current_total_loss,current_domain_loss,current_bdc_loss))\n",
    "        \n",
    "            # evaluate the errors in f-domain\n",
    "            record_predictions()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "callbacks = [\n",
    "    Per_X_Epoch_Record(record_interval=200,verbose=1),\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:    0.00000 | total_loss:    6.14656 | domain_loss:  557.84418 | bdc_loss:    0.57386\n",
      "epoch:  200.00000 | total_loss:    0.89216 | domain_loss:   38.97280 | bdc_loss:    0.50751\n",
      "epoch:  400.00000 | total_loss:    0.53527 | domain_loss:    8.76478 | bdc_loss:    0.45214\n",
      "epoch:  600.00000 | total_loss:    0.43201 | domain_loss:    3.48957 | bdc_loss:    0.40112\n",
      "epoch:  800.00000 | total_loss:    0.36766 | domain_loss:    1.89692 | bdc_loss:    0.35221\n",
      "epoch: 1000.00000 | total_loss:    0.31536 | domain_loss:    1.20640 | bdc_loss:    0.30636\n",
      "epoch: 1200.00000 | total_loss:    0.27248 | domain_loss:    0.81165 | bdc_loss:    0.26704\n",
      "epoch: 1400.00000 | total_loss:    0.24123 | domain_loss:    0.55162 | bdc_loss:    0.23809\n",
      "epoch: 1600.00000 | total_loss:    0.22225 | domain_loss:    0.38180 | bdc_loss:    0.22063\n",
      "epoch: 1800.00000 | total_loss:    0.21260 | domain_loss:    0.27849 | bdc_loss:    0.21193\n",
      "epoch: 2000.00000 | total_loss:    0.20791 | domain_loss:    0.21913 | bdc_loss:    0.20780\n",
      "epoch: 2200.00000 | total_loss:    0.20508 | domain_loss:    0.18772 | bdc_loss:    0.20525\n",
      "epoch: 2400.00000 | total_loss:    0.20271 | domain_loss:    0.17514 | bdc_loss:    0.20299\n",
      "epoch: 2600.00000 | total_loss:    0.20035 | domain_loss:    0.17630 | bdc_loss:    0.20059\n",
      "epoch: 2800.00000 | total_loss:    0.19783 | domain_loss:    0.18838 | bdc_loss:    0.19793\n",
      "epoch: 3000.00000 | total_loss:    0.19507 | domain_loss:    0.21007 | bdc_loss:    0.19492\n",
      "epoch: 3200.00000 | total_loss:    0.19198 | domain_loss:    0.24122 | bdc_loss:    0.19148\n",
      "epoch: 3400.00000 | total_loss:    0.18847 | domain_loss:    0.28258 | bdc_loss:    0.18752\n",
      "epoch: 3600.00000 | total_loss:    0.18445 | domain_loss:    0.33572 | bdc_loss:    0.18292\n",
      "epoch: 3800.00000 | total_loss:    0.17979 | domain_loss:    0.40284 | bdc_loss:    0.17754\n",
      "epoch: 4000.00000 | total_loss:    0.17435 | domain_loss:    0.48657 | bdc_loss:    0.17120\n",
      "epoch: 4200.00000 | total_loss:    0.16798 | domain_loss:    0.58955 | bdc_loss:    0.16373\n",
      "epoch: 4400.00000 | total_loss:    0.16053 | domain_loss:    0.71346 | bdc_loss:    0.15494\n",
      "epoch: 4600.00000 | total_loss:    0.15187 | domain_loss:    0.85748 | bdc_loss:    0.14474\n",
      "epoch: 4800.00000 | total_loss:    0.14197 | domain_loss:    1.01623 | bdc_loss:    0.13314\n",
      "epoch: 5000.00000 | total_loss:    0.13093 | domain_loss:    1.17805 | bdc_loss:    0.12035\n",
      "epoch: 5200.00000 | total_loss:    0.11903 | domain_loss:    1.32537 | bdc_loss:    0.10685\n",
      "epoch: 5400.00000 | total_loss:    0.10680 | domain_loss:    1.43865 | bdc_loss:    0.09335\n",
      "epoch: 5600.00000 | total_loss:    0.09495 | domain_loss:    1.50370 | bdc_loss:    0.08072\n",
      "epoch: 5800.00000 | total_loss:    0.08427 | domain_loss:    1.51899 | bdc_loss:    0.06978\n",
      "epoch: 6000.00000 | total_loss:    0.07541 | domain_loss:    1.49688 | bdc_loss:    0.06105\n",
      "epoch: 6200.00000 | total_loss:    0.06861 | domain_loss:    1.45660 | bdc_loss:    0.05459\n",
      "epoch: 6400.00000 | total_loss:    0.06368 | domain_loss:    1.41441 | bdc_loss:    0.05004\n",
      "epoch: 6600.00000 | total_loss:    0.06016 | domain_loss:    1.37827 | bdc_loss:    0.04685\n",
      "epoch: 6800.00000 | total_loss:    0.05755 | domain_loss:    1.34904 | bdc_loss:    0.04450\n",
      "epoch: 7000.00000 | total_loss:    0.05544 | domain_loss:    1.32409 | bdc_loss:    0.04263\n",
      "epoch: 7200.00000 | total_loss:    0.05354 | domain_loss:    1.30022 | bdc_loss:    0.04095\n",
      "epoch: 7400.00000 | total_loss:    0.05163 | domain_loss:    1.27479 | bdc_loss:    0.03928\n",
      "epoch: 7600.00000 | total_loss:    0.04953 | domain_loss:    1.24305 | bdc_loss:    0.03748\n",
      "epoch: 7800.00000 | total_loss:    0.04716 | domain_loss:    1.20098 | bdc_loss:    0.03550\n",
      "epoch: 8000.00000 | total_loss:    0.04424 | domain_loss:    1.11911 | bdc_loss:    0.03338\n",
      "epoch: 8200.00000 | total_loss:    0.04043 | domain_loss:    0.97913 | bdc_loss:    0.03095\n",
      "epoch: 8400.00000 | total_loss:    0.03605 | domain_loss:    0.80477 | bdc_loss:    0.02829\n",
      "epoch: 8600.00000 | total_loss:    0.03139 | domain_loss:    0.61977 | bdc_loss:    0.02545\n",
      "epoch: 8800.00000 | total_loss:    0.02706 | domain_loss:    0.48151 | bdc_loss:    0.02247\n",
      "epoch: 9000.00000 | total_loss:    0.02344 | domain_loss:    0.38639 | bdc_loss:    0.01978\n",
      "epoch: 9200.00000 | total_loss:    0.02039 | domain_loss:    0.31349 | bdc_loss:    0.01742\n",
      "epoch: 9400.00000 | total_loss:    0.01777 | domain_loss:    0.25688 | bdc_loss:    0.01536\n",
      "epoch: 9600.00000 | total_loss:    0.01554 | domain_loss:    0.21280 | bdc_loss:    0.01355\n",
      "epoch: 9800.00000 | total_loss:    0.01367 | domain_loss:    0.17854 | bdc_loss:    0.01201\n",
      "epoch: 10000.00000 | total_loss:    0.01210 | domain_loss:    0.15130 | bdc_loss:    0.01069\n",
      "epoch: 10200.00000 | total_loss:    0.01073 | domain_loss:    0.12818 | bdc_loss:    0.00954\n",
      "epoch: 10400.00000 | total_loss:    0.00951 | domain_loss:    0.10798 | bdc_loss:    0.00852\n",
      "epoch: 10600.00000 | total_loss:    0.00840 | domain_loss:    0.08994 | bdc_loss:    0.00758\n",
      "epoch: 10800.00000 | total_loss:    0.00739 | domain_loss:    0.07381 | bdc_loss:    0.00672\n",
      "epoch: 11000.00000 | total_loss:    0.00647 | domain_loss:    0.05984 | bdc_loss:    0.00594\n",
      "epoch: 11200.00000 | total_loss:    0.00572 | domain_loss:    0.04948 | bdc_loss:    0.00528\n",
      "epoch: 11400.00000 | total_loss:    0.00510 | domain_loss:    0.04161 | bdc_loss:    0.00473\n",
      "epoch: 11600.00000 | total_loss:    0.00457 | domain_loss:    0.03866 | bdc_loss:    0.00423\n",
      "epoch: 11800.00000 | total_loss:    0.00400 | domain_loss:    0.02656 | bdc_loss:    0.00377\n",
      "epoch: 12000.00000 | total_loss:    0.00349 | domain_loss:    0.01811 | bdc_loss:    0.00334\n",
      "epoch: 12200.00000 | total_loss:    0.00309 | domain_loss:    0.01331 | bdc_loss:    0.00298\n",
      "epoch: 12400.00000 | total_loss:    0.00277 | domain_loss:    0.00985 | bdc_loss:    0.00270\n",
      "epoch: 12600.00000 | total_loss:    0.00252 | domain_loss:    0.00717 | bdc_loss:    0.00248\n",
      "epoch: 12800.00000 | total_loss:    0.00233 | domain_loss:    0.00512 | bdc_loss:    0.00230\n",
      "epoch: 13000.00000 | total_loss:    0.00218 | domain_loss:    0.00359 | bdc_loss:    0.00217\n",
      "epoch: 13200.00000 | total_loss:    0.00207 | domain_loss:    0.00247 | bdc_loss:    0.00207\n",
      "epoch: 13400.00000 | total_loss:    0.00199 | domain_loss:    0.00161 | bdc_loss:    0.00200\n",
      "epoch: 13600.00000 | total_loss:    0.00194 | domain_loss:    0.00106 | bdc_loss:    0.00195\n",
      "epoch: 13800.00000 | total_loss:    0.00191 | domain_loss:    0.00150 | bdc_loss:    0.00191\n",
      "epoch: 14000.00000 | total_loss:    0.00189 | domain_loss:    0.00150 | bdc_loss:    0.00189\n",
      "epoch: 14200.00000 | total_loss:    0.00186 | domain_loss:    0.00030 | bdc_loss:    0.00188\n",
      "epoch: 14400.00000 | total_loss:    0.00185 | domain_loss:    0.00022 | bdc_loss:    0.00187\n",
      "epoch: 14600.00000 | total_loss:    0.00185 | domain_loss:    0.00019 | bdc_loss:    0.00187\n",
      "epoch: 14800.00000 | total_loss:    0.00185 | domain_loss:    0.00016 | bdc_loss:    0.00186\n",
      "epoch: 15000.00000 | total_loss:    0.00185 | domain_loss:    0.00015 | bdc_loss:    0.00186\n",
      "epoch: 15200.00000 | total_loss:    0.00184 | domain_loss:    0.00015 | bdc_loss:    0.00186\n",
      "epoch: 15400.00000 | total_loss:    0.00184 | domain_loss:    0.00016 | bdc_loss:    0.00186\n",
      "epoch: 15600.00000 | total_loss:    0.00184 | domain_loss:    0.00015 | bdc_loss:    0.00186\n",
      "epoch: 15800.00000 | total_loss:    0.00184 | domain_loss:    0.00015 | bdc_loss:    0.00186\n",
      "epoch: 16000.00000 | total_loss:    0.00185 | domain_loss:    0.00076 | bdc_loss:    0.00186\n",
      "epoch: 16200.00000 | total_loss:    0.00184 | domain_loss:    0.00015 | bdc_loss:    0.00186\n",
      "epoch: 16400.00000 | total_loss:    0.00184 | domain_loss:    0.00015 | bdc_loss:    0.00186\n",
      "epoch: 16600.00000 | total_loss:    0.00184 | domain_loss:    0.00015 | bdc_loss:    0.00186\n",
      "epoch: 16800.00000 | total_loss:    0.00185 | domain_loss:    0.00030 | bdc_loss:    0.00186\n",
      "epoch: 17000.00000 | total_loss:    0.00184 | domain_loss:    0.00020 | bdc_loss:    0.00186\n",
      "epoch: 17200.00000 | total_loss:    0.00185 | domain_loss:    0.00059 | bdc_loss:    0.00186\n",
      "epoch: 17400.00000 | total_loss:    0.00184 | domain_loss:    0.00018 | bdc_loss:    0.00186\n",
      "epoch: 17600.00000 | total_loss:    0.00184 | domain_loss:    0.00017 | bdc_loss:    0.00186\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 17800.00000 | total_loss:    0.00184 | domain_loss:    0.00015 | bdc_loss:    0.00186\n",
      "epoch: 18000.00000 | total_loss:    0.00184 | domain_loss:    0.00016 | bdc_loss:    0.00186\n",
      "epoch: 18200.00000 | total_loss:    0.00185 | domain_loss:    0.00023 | bdc_loss:    0.00186\n",
      "epoch: 18400.00000 | total_loss:    0.00184 | domain_loss:    0.00015 | bdc_loss:    0.00186\n",
      "epoch: 18600.00000 | total_loss:    0.00184 | domain_loss:    0.00015 | bdc_loss:    0.00186\n",
      "epoch: 18800.00000 | total_loss:    0.00185 | domain_loss:    0.00026 | bdc_loss:    0.00186\n",
      "epoch: 19000.00000 | total_loss:    0.00184 | domain_loss:    0.00015 | bdc_loss:    0.00186\n",
      "epoch: 19200.00000 | total_loss:    0.00184 | domain_loss:    0.00016 | bdc_loss:    0.00186\n",
      "epoch: 19400.00000 | total_loss:    0.00185 | domain_loss:    0.00043 | bdc_loss:    0.00186\n",
      "epoch: 19600.00000 | total_loss:    0.00185 | domain_loss:    0.00023 | bdc_loss:    0.00186\n",
      "epoch: 19800.00000 | total_loss:    0.00184 | domain_loss:    0.00016 | bdc_loss:    0.00186\n"
     ]
    }
   ],
   "source": [
    "epoch_number_list = []\n",
    "total_loss_list = []\n",
    "domain_loss_list = []\n",
    "boundary_loss_list = []\n",
    "uxy_list = []\n",
    "dudx_list = []\n",
    "dudy_list = []\n",
    "d2udx2_list = []\n",
    "d2udy2_list = []\n",
    "d2udxdy_list = []\n",
    "laplace_list = []\n",
    "pde_model_train.load_weights('picn_initial_weights.h5')\n",
    "pde_model_train.compile(optimizer=keras.optimizers.Adam(learning_rate=0.0002), loss=\"mse\", loss_weights = [0.01, 0.99])\n",
    "pde_model_train.fit(x=training_input_data, \n",
    "                    y=training_label_data, \n",
    "                    epochs=20000, verbose=0,\n",
    "                    callbacks=callbacks)\n",
    "pde_model_train.load_weights('picn_best_weights.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8. LOSS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df=pd.DataFrame({'epoch': epoch_number_list, \n",
    "                 'total_loss': total_loss_list, \n",
    "                 'governing_loss': domain_loss_list, \n",
    "                 'boundary_loss': boundary_loss_list})\n",
    "\n",
    "plt.figure(figsize=(12, 4))\n",
    "plt.plot( 'epoch', 'total_loss', data=df, marker='o', markerfacecolor='red', markersize=2, color='skyblue', linewidth=3)\n",
    "plt.plot( 'epoch', 'governing_loss', data=df, marker='', color='green', linewidth=2, linestyle='dashed')\n",
    "plt.plot( 'epoch', 'boundary_loss', data=df, marker='', color='blue', linewidth=2, linestyle='dashed')\n",
    "plt.legend()\n",
    "#plt.xscale('log')\n",
    "plt.yscale('log')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "[x_m, y_m, uxy, dudx, dudy, d2udx2, d2udy2, d2udxdy, laplace] = pde_model.predict(training_input_data[:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9. Results overview"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'smooth')"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x216 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(1,4,constrained_layout=False, figsize=(18, 3))\n",
    "#\n",
    "ax = axs.ravel()[0]\n",
    "temp = uxy[0,:,:,0]\n",
    "cs = ax.contourf(x_domain, y_domain, uxy[0,:,:,0],20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('prediction')\n",
    "#\n",
    "ax = axs.ravel()[1]\n",
    "cs = ax.contourf(x_domain, y_domain, truth_data,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('truth')\n",
    "#\n",
    "ax = axs.ravel()[2]\n",
    "cs = ax.contourf(x_domain, y_domain, uxy[0,:,:,0]-truth_data,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('error')\n",
    "#\n",
    "ax = axs.ravel()[3]\n",
    "cs = ax.contourf(x_domain, y_domain, truth_smooth,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('smooth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<tf.Variable 'conv2d_7/kernel:0' shape=(1, 1, 2, 1) dtype=float32, numpy=\n",
       " array([[[[0.200824 ],\n",
       "          [1.0117333]]]], dtype=float32)>]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pde_model_train.layers[-6].weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.99776625"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.19955325*5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 10. Save the Process Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "picn_process_data = {'x_domain':x_domain,\n",
    "                     'y_domain':y_domain,\n",
    "                     'epoch_number_list':np.asarray(epoch_number_list),\n",
    "                     'total_loss_list':np.asarray(total_loss_list),\n",
    "                     'domain_loss_list':np.asarray(domain_loss_list),\n",
    "                     'boundary_loss_list':np.asarray(boundary_loss_list),\n",
    "                     'truth_data':np.asarray(truth_data),\n",
    "                     'uxy_list':np.concatenate(uxy_list,axis=0),\n",
    "                     'dudx_list':np.concatenate(dudx_list,axis=0),\n",
    "                     'dudy_list':np.concatenate(dudy_list,axis=0),\n",
    "                     'd2udx2_list':np.concatenate(d2udx2_list,axis=0),\n",
    "                     'd2udy2_list':np.concatenate(d2udy2_list,axis=0),\n",
    "                     'd2udxdy_list':np.concatenate(d2udxdy_list,axis=0),\n",
    "                     'laplace_list':np.concatenate(laplace_list,axis=0),\n",
    "                     'k1':pde_model_train.layers[-6].weights[0][0,0,0,0].numpy(),\n",
    "                     'k2':pde_model_train.layers[-6].weights[0][0,0,1,0].numpy()}\n",
    "savemat('picn_process_data.mat', picn_process_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.200824"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pde_model_train.layers[-6].weights[0][0,0,0,0].numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0117333"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pde_model_train.layers[-6].weights[0][0,0,1,0].numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.03791"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pde_model_train.layers[-6].weights[0][0,0,1,0].numpy()/pde_model_train.layers[-6].weights[0][0,0,0,0].numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7581996917724609"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(pde_model_train.layers[-6].weights[0][0,0,1,0].numpy()/pde_model_train.layers[-6].weights[0][0,0,0,0].numpy()-5)/5*100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
